import envConfig from './env-config.js'

// 创建请求实例的工厂函数
export const baseRequest = () => {
  // 基础配置
  const baseConfig = {
    baseURL: envConfig.API_SERVICE,
    timeout: envConfig.TIMEOUT,
    header: {
      'Content-Type': 'application/json'
    }
  }

  // 请求方法封装
  const request = (options) => {
    // 合并配置
    const config = {
      ...baseConfig,
      ...options,
      url: (baseConfig.baseURL || '') + (options.url || ''),
      header: {
        ...baseConfig.header,
        ...options.header
      }
    }

    // 请求拦截处理
    const token = uni.getStorageSync('zbox-token')
    // 不需要token的接口白名单
    const whiteList = ['/user/login', '/user/register']
    const isWhiteList = whiteList.some(path => {
      // 将当前请求的url和白名单路径都转换为小写进行比较
      const currentPath = options.url.toLowerCase()
      const whiteListPath = path.toLowerCase()
      return currentPath.includes(whiteListPath)
    })

    // 如果不在白名单中，需要添加token
    if (!isWhiteList) {
      if (!token) {
        // token不存在时跳转到登录页
        uni.showToast({
          title: '请先登录',
          icon: 'none'
        })
        setTimeout(() => {
          uni.reLaunch({
            url: '/pages/login/login'
          })
        }, 1500)
        return Promise.reject(new Error('请先登录'))
      }
      // 添加token到请求头
      config.header.Authorization = token
    }

    console.log('Request URL:', config.url)
    console.log('Request config:', config)

    // 返回 Promise
    return new Promise((resolve, reject) => {
      uni.request({
        ...config,
        success: (response) => {
          console.log('Response:', response)
          const res = response.data

          // 处理token过期
          if (res.code === '10005') {
            uni.showToast({
              title: '登录已过期，请重新登录',
              icon: 'none'
            })
            // 清除token和用户信息
            uni.removeStorageSync('zbox-token')
            uni.removeStorageSync('zbox-userId')
            uni.removeStorageSync('zbox-username')
            uni.removeStorageSync('zbox-account')
            // 跳转到登录页
            setTimeout(() => {
              uni.reLaunch({
                url: '/pages/login/login'
              })
            }, 1500)
            reject(new Error(res.msg || 'token expired'))
            return
          }

          // 处理业务失败
          if (res.code !== '00000' && !res.success) {
            uni.showToast({
              title: res.msg || res.message || '请求失败',
              icon: 'none'
            })
            reject(new Error(res.msg || res.message || '请求失败'))
            return
          }

          resolve(res)
        },
        fail: (error) => {
          console.error('Request error:', error)

          // 请求超时处理
          if (error.errMsg && error.errMsg.includes('timeout')) {
            uni.showToast({
              title: '请求超时，请稍后重试',
              icon: 'none'
            })
            reject(error)
            return
          }

          // 网络错误处理
          if (error.errMsg && error.errMsg.includes('fail')) {
            uni.showToast({
              title: '网络连接失败，请检查网络设置',
              icon: 'none'
            })
            reject(error)
            return
          }

          // 服务器错误处理
          if (error.statusCode >= 500) {
            uni.showToast({
              title: '服务器错误，请稍后重试',
              icon: 'none'
            })
            reject(error)
            return
          }

          // 其他错误
          uni.showToast({
            title: '请求失败，请稍后重试',
            icon: 'none'
          })
          reject(error)
        }
      })
    })
  }

  // 封装常用请求方法
  return {
    get: (url, params = {}, options = {}) => {
      return request({
        url,
        method: 'GET',
        data: params,
        ...options
      })
    },
    post: (url, data = {}, options = {}) => {
      return request({
        url,
        method: 'POST',
        data,
        ...options
      })
    },
    put: (url, data = {}, options = {}) => {
      return request({
        url,
        method: 'PUT',
        data,
        ...options
      })
    },
    delete: (url, data = {}, options = {}) => {
      return request({
        url,
        method: 'DELETE',
        data,
        ...options
      })
    },
    // 文件上传
    upload: (url, filePath, formData = {}, options = {}) => {
      return new Promise((resolve, reject) => {
        const token = uni.getStorageSync(envConfig.TOKEN_KEY)

        uni.uploadFile({
          url: envConfig.API_SERVICE + url,
          filePath,
          name: 'file',
          formData,
          timeout: envConfig.TIMEOUT,
          header: {
            'Authorization': token ? token : '',
            ...options.header
          },
          success: (response) => {
            try {
              const data = JSON.parse(response.data)
              if (data.code === '00000' || data.success === true) {
                resolve(data)
              } else {
                const errorMsg = data.message || data.msg || '上传失败'
                uni.showToast({
                  title: errorMsg,
                  icon: 'none'
                })
                reject(new Error(errorMsg))
              }
            } catch (error) {
              reject(error)
            }
          },
          fail: (error) => {
            uni.showToast({
              title: '上传失败',
              icon: 'none'
            })
            reject(error)
          }
        })
      })
    }
  }
}

// 创建默认请求实例
const http = baseRequest()

export default http 